/*
未来之窗昭和先君
 未来之窗库
 javascript query design by cyberwin
 2022-7-8 
*/
/*
 未来之窗库 - 扩展版本
 javascript query design by cyberwin
 扩展功能: each方法、AJAX支持、WLZC_serializeJson方法
 2025-8-29
*/

function $cq(cyberobjname){
    return  new cyberwin_query(cyberobjname);
}

function cyberwin_query(cyberobjname){//参数是变体变量
	/*
   this.elements=[];//选择器选择的元素扔到这个数组中
   // this.elements=[];//选择器选择的元素扔到这个数组中
  var idn= cyberobjname.startsWith("#");
  var obj_id=cyberobjname.replace("#","");

  var obj =document.getElementById(obj_id);
  return obj;*/
  this.elements=[];//选择器选择的元素扔到这个数组中
    switch(typeof cyberobjname){
        //如果参数是函数
        case 'function':
            myAddEvent(window,'load',cyberobjname);
            break;
        //如果参数是字符串
        case 'string2025':
            switch(cyberobjname.charAt(0)){
                case '#'://id选择器参数应该为#号之后的字符段
				    console.log("未来之窗操作器寻找id",cyberobjname.substring(1));
                    var obj=document.getElementById(cyberobjname.substring(1));
                    this.elements.push(obj);
					console.log("未来之窗操作器寻找id",obj);
                break;

                case '.'://class
			     {
                   // this.elements=getByClass(document,cyberobjname.substring(1));
				   this.elements = getSelectorByClassv2008(document,cyberobjname);
				 }
                    break;

                default://标签
                    this.elements=document.getElementsByTagName(cyberobjname);
            }
            break;
		case 'string':
		{
			this.elements = getSelectorALLv2025(document,cyberobjname);
		}
		 break;
        //如果参数是对象。
        case 'object':
            this.elements.push(cyberobjname);
            
    }

}


//取值方法
cyberwin_query.prototype.val=function(value){
    if(arguments.length==1){//当参数个数为2时，使用设置css的方法
        var i=0;
        for(i=0;i<this.elements.length;i++){
            this.elements[i].value=value;
        }
    }else{//只有一个参数时获取样式
        return this.elements[0].value;;
    }
};



//2022-7-8 样式
//css方法
cyberwin_query.prototype.css=function(attr,value){
    if(arguments.length==2){//当参数个数为2时，使用设置css的方法
        var i=0;
        for(i=0;i<this.elements.length;i++){
            this.elements[i].style[attr]=value;
            
        }
    }else{//只有一个参数时获取样式
        return getStyle(this.elements[0],attr);
    }
};



//eq选择器
cyberwin_query.prototype.eq=function(n){
    return new cyberwin_query(this.elements[n]);
}

// 
//对选择器函数绑定click事件
cyberwin_query.prototype.click=function(fn){
    var i=0;
    //对于返回器数组的内容
    for(i=0;i<this.elements.length;i++){
        myAddEvent(this.elements[i],'click',fn);
    }
}

cyberwin_query.prototype.find=function(str){
    var i=0;
    var cyberwin_find_Result=[];//存放临时数据

    for(i=0;i<this.elements.length;i++){
		/*
        switch(str.charAt(0)){

            case '.'://class类
                var aEle=getByClass(this.elements[i],str.substring(1));
            aResult.concat(aEle);//桥接到aResult内。但是
            break;

            default://其它标签名(TagName)
                var aEle=this.elements[i].getElementsByTagName(str);
                appendArr(aResult,aEle);
        }
		*/

		var ImmortalRealm_ul = getSelectorALLv2025(this.elements[i],str);
		//console.log("仙域",ImmortalRealm_ul);
		//仙域子民
		 var i_underling=0;
		 //for(i_underling=0;i_underling < this.ImmortalRealm_ul.length;i_underling++){
		 for (let i_underling in ImmortalRealm_ul) {
			 cyberwin_find_Result.push(ImmortalRealm_ul[i_underling]);//桥接到aResult内。但是
		 }

		
    }
  //  var newdQuery=new cyberwin_query();
  //  newdQuery.elements=aResult;
    //return newdQuery;//保持可链。
	//this.elements = aResult;
	//return this;
	 var newdQuery=new cyberwin_query();
   newdQuery.elements=cyberwin_find_Result;
    return newdQuery;//保持可链。
}


//可重复调用的加载函数
function myAddEvent(obj,sEv,fn){
    if(obj.attachEvent){
        obj.attachEvent('on'+sEv,function(){
            fn.call(obj);//兼容ie
        });
    }else{
        obj.addEventListener(sEv,fn,false);
    }
}

//class选择器调用函数
function getByClass(oParent,sClass){
    var aEle=oParent.getElementsByTagName('*');//选择父元素的所有元素
    var aResult=[];
    var re=new RegExp('\\b'+sClass+'\\b','i');//正则边界
    var i=0;
    for(i=0;i<aEle.length;i++){
        if(re.test(aEle[i].className)){
            aResult.push(aEle[i]);
        }
    }
    return aResult;
}

//获取计算后的样式
function getStyle(obj,attr){
    //元素，样式
    if(obj.currentStyle){//兼容ie9及以下
        return obj.currentStyle[attr];
    }else{
        return getComputedStyle(obj,false)[attr];
    }
}


//对选择器函数绑定show/hide事件
cyberwin_query.prototype.show=function(){
    var i=0;
    //对于返回器数组的内容
    for(i=0;i<this.elements.length;i++){
        this.elements[i].style.display='block';
    }
}

cyberwin_query.prototype.hide=function(){
    var i=0;
    //对于返回器数组的内容
    for(i=0;i<this.elements.length;i++){
        this.elements[i].style.display='none';
    }
};

function getSelectorByClassv2008(oParent,sClass){
    //var aEle=oParent.getElementsByTagName('*');//选择父元素的所有元素
   // var aResult=[];
    //var re=new RegExp('\\b'+sClass+'\\b','i');//正则边界
	//var aEle= oParent.querySelector(sClass); 
	//querySelectorAll
	var Cyberwin_Ele= oParent.querySelectorAll(sClass); 
	//console.log("未来之窗操作器text",Cyberwin_Ele);

	var cyberwin_ret=[];
    var i=0;
    for(i=0;i<Cyberwin_Ele.length;i++){
		//console.log("未来之窗操作器text",Cyberwin_Ele[i]);
        //if(re.test(Cyberwin_Ele[i].className)){
            cyberwin_ret.push(Cyberwin_Ele[i]);
       // }
    }
    return cyberwin_ret;
}


function getSelectorALLv2025(oParent,sClass){
    //var aEle=oParent.getElementsByTagName('*');//选择父元素的所有元素
   // var aResult=[];
    //var re=new RegExp('\\b'+sClass+'\\b','i');//正则边界
	//var aEle= oParent.querySelector(sClass); 
	//querySelectorAll
	var Cyberwin_Ele= oParent.querySelectorAll(sClass); 
	//console.log("getSelectorALLv2025",sClass,Cyberwin_Ele);

	var cyberwin_ret=[];
    var i=0;
    for(i=0;i<Cyberwin_Ele.length;i++){
		//console.log("未来之窗操作器text",Cyberwin_Ele[i]);
        //if(re.test(Cyberwin_Ele[i].className)){
            cyberwin_ret.push(Cyberwin_Ele[i]);
       // }
    }
    return cyberwin_ret;
}

//2025-8-29
//innerText innerHTML
cyberwin_query.prototype.text=function(value){
	console.log("未来之窗操作器text",this);
	const that=this;

    if(arguments.length==1){//当参数个数为2时，使用设置css的方法
        var i=0;
		console.log("未来之窗操作器text");
        for(i=0;i<that.elements.length;i++){
			console.log("未来之窗操作器",that.elements[i]);
            that.elements[i].innerText=value;
        }
    }else{//只有一个参数时获取样式
        return that.elements[0].innerText;;
    }
};

cyberwin_query.prototype.html=function(value){
	const that=this;
    if(arguments.length==1){//当参数个数为2时，使用设置css的方法
        var i=0;
        for(i=0;i<that.elements.length;i++){
            that.elements[i].innerHTML=value;
        }
    }else{//只有一个参数时获取样式
        return that.elements[0].innerHTML;;
    }
};
//////////////////////////////////////////////////////////
//获取数据
// 模拟 jQuery 的 data() 方法，用于获取和设置 data-* 属性
cyberwin_query.prototype.data = function(key, value) {
    // 如果没有参数，返回所有data属性的集合
    if (arguments.length === 0) {
        if (this.elements.length === 0) return null;
        
        var data = {};
        var dataset = this.elements[0].dataset;
        
        // 遍历所有data属性
        for (var prop in dataset) {
            if (dataset.hasOwnProperty(prop)) {
                // 尝试将值转换为适当的类型
                data[prop] = this.convertDataValue(dataset[prop]);
            }
        }
        return data;
    }
    
    // 如果只有一个参数，获取指定的data属性
    if (arguments.length === 1) {
        if (this.elements.length === 0) return undefined;
        
        // 转换为驼峰式命名，因为dataset使用驼峰式
        var camelCaseKey = this.toCamelCase(key);
        var value = this.elements[0].dataset[camelCaseKey];
        
        // 转换数据类型
        return this.convertDataValue(value);
    }
    
    // 两个参数，设置data属性
    if (arguments.length === 2) {
        var camelCaseKey = this.toCamelCase(key);
        
        for (var i = 0; i < this.elements.length; i++) {
            // 设置dataset属性，自动处理为data-*属性
            this.elements[i].dataset[camelCaseKey] = value;
        }
        
        // 支持链式调用
        return this;
    }
};

// 辅助方法：将连字符命名转换为驼峰式命名
cyberwin_query.prototype.toCamelCase = function(str) {
    return str.replace(/-([a-z])/g, function(match, letter) {
        return letter.toUpperCase();
    });
};

// 辅助方法：将字符串值转换为适当的数据类型
cyberwin_query.prototype.convertDataValue = function(value) {
    if (value === undefined) return undefined;
    
    // 尝试转换为数字
    if (!isNaN(value) && value !== '') {
        return Number(value);
    }
    
    // 转换布尔值
    if (value === 'true') return true;
    if (value === 'false') return false;
    
    // 尝试解析JSON
    try {
        return JSON.parse(value);
    } catch (e) {
        // 不是JSON，返回原始字符串
        return value;
    }
};

////////////////////////////////////////////////////////

///////////////////////////////////////
//属性
// 模拟 jQuery 的 attr() 方法，用于获取和设置元素属性
cyberwin_query.prototype.attr = function(name, value) {
    // 没有元素时返回null
    if (this.elements.length === 0) {
        return null;
    }
    
    // 情况1: 传入一个对象，批量设置属性
    if (typeof name === 'object') {
        for (var prop in name) {
            if (name.hasOwnProperty(prop)) {
                this.attr(prop, name[prop]);
            }
        }
        return this; // 支持链式调用
    }
    
    // 情况2: 只传入属性名，获取属性值
	//console.log("attr",this.elements);
	//console.log("attr",this.elements[0]);
    if (arguments.length === 1) {
        return this.elements[0].getAttribute(name);
    }
    
    // 情况3: 传入属性名和值，设置属性
    if (arguments.length === 2) {
        // 对所有匹配元素设置属性
        for (var i = 0; i < this.elements.length; i++) {
            // 如果值为null，则移除该属性
            if (value === null) {
                this.elements[i].removeAttribute(name);
            } else {
                this.elements[i].setAttribute(name, value);
            }
        }
        return this; // 支持链式调用
    }
};

// 额外添加removeAttr方法，用于移除属性
cyberwin_query.prototype.removeAttr = function(name) {
    for (var i = 0; i < this.elements.length; i++) {
        this.elements[i].removeAttribute(name);
    }
    return this; // 支持链式调用
};
///////////////////////////////////////////////////////////////////////////////////////////

//排除
// 模拟 jQuery 的 not() 方法
cyberwin_query.prototype.not = function(selector) {
    // 存储过滤后的元素
    var filtered = [];
    var i, j, len, elem, match;
    
    // 遍历当前所有元素
    for (i = 0, len = this.elements.length; i < len; i++) {
        elem = this.elements[i];
        match = false;
        
        // 根据不同类型的选择器进行匹配检查
        if (typeof selector === 'string') {
            // 选择器字符串 - 检查元素是否匹配该选择器
            match = this.matchesSelector(elem, selector);
        } 
        else if (selector.nodeType) {
            // DOM 元素 - 检查是否为同一个元素
            match = elem === selector;
        } 
        else if (typeof selector === 'function') {
            // 函数 - 执行函数，返回true表示要排除
            match = selector.call(elem, i, elem);
        }
        else if (selector instanceof cyberwin_query) {
            // 另一个cyberwin_query对象 - 检查是否存在于该对象中
            for (j = 0; j < selector.elements.length; j++) {
                if (elem === selector.elements[j]) {
                    match = true;
                    break;
                }
            }
        }
        
        // 如果不匹配，则保留该元素
        if (!match) {
            filtered.push(elem);
        }
    }
    
    // 创建并返回新的cyberwin_query对象
    var newQuery = new cyberwin_query();
    newQuery.elements = filtered;
    return newQuery;
};

// 辅助方法：检查元素是否匹配选择器
cyberwin_query.prototype.matchesSelector = function(elem, selector) {
    // 现代浏览器支持的方法
    if (elem.matches) {
        return elem.matches(selector);
    }
    // 兼容旧版浏览器
    else if (elem.msMatchesSelector) {
        return elem.msMatchesSelector(selector);
    }
    else if (elem.webkitMatchesSelector) {
        return elem.webkitMatchesSelector(selector);
    }
    // 降级处理：使用选择器查找元素并检查是否包含当前元素
    else {
        var matches = (elem.document || elem.ownerDocument).querySelectorAll(selector);
        for (var i = 0; i < matches.length; i++) {
            if (matches[i] === elem) {
                return true;
            }
        }
        return false;
    }
};
//////////////////////////////////////////////////////
// 1. 添加each方法
cyberwin_query.prototype.each = function(callback) {
    if (typeof callback === 'function') {
        for (var i = 0; i < this.elements.length; i++) {
            // 执行回调函数，传入索引和当前元素，this指向当前元素
            callback.call(this.elements[i], i, this.elements[i]);
        }
    }
    return this; // 支持链式调用
};

//2025-08-29 表单校验
cyberwin_query.prototype.未东方仙盟_通用技术_检测表单 = function(tiptype) {
      var 通过检测=true;
	  const that=this;
/*
	   for(i=0;i<that.elements.length;i++){
			console.log("未东方仙盟_通用技术_检测表单",that.elements[i]);
            that.each(that.find("input,select,textarea,select"))
        }
			*/
			//that.find("input,select,textarea,select")
			/*
			$cq(".通用输入").each(function(){
    alert($cq(this).val())
  });*/
		that.each()
			that.each(function(){
				//alert($cq(this).val())
				   //console.log("仙域表单=",this);
				   const current_ImmortalRealm=this;
                   var current_underling_ImmortalRealm_elements_container = $cq(current_ImmortalRealm).find("input,select,textarea,select");
				  //  console.log("子民=",current_underling_ImmortalRealm_elements_container);
					//仙域大陆之圣天子民
					const current_underling_ImmortalRealm= current_underling_ImmortalRealm_elements_container.elements;

					for (let i_underling in current_underling_ImmortalRealm) {
						const iiunderling=current_underling_ImmortalRealm[i_underling];
						//console.log("仙域大陆之圣天子民子民=",iiunderling);

					    var validtips = $cq(iiunderling).attr('validtips');
						//console.log("仙域大陆之圣天子民子民=",validtips);
						var 校验混合 = $cq(iiunderling).attr('validform');
						if(校验混合){
					               varlidate_arr = 校验混合.split(',');
									for(var i in varlidate_arr){
										if(varlidate_arr[i] == 'required:true'){

											if($cq(iiunderling).val() == ''){
												//$(item).parent().append('<em for="'+em_for+'" generated="true" class="error tips">必填项</em>');
												//alert(validtips);
												if(tiptype == "layer"){
													that.showAlert(validtips, "error", 5000,"校验");
												}else{
													alert(validtips);
												}
												
												通过检测 = false;
												return 通过检测;
											}else{
												//$(item).parent().append('<em for="'+em_for+'" generated="true" class="error success"></em>');
											}
											//break;
										}
									}
					  }

					}


			  });
/*
		$.each($('#'+魔都).find("input,select,textarea,select").not(":submit,:reset,:image,[disabled]"),function(i,灵体){
			        var 校验提示 = $(灵体).attr('validtips');
			        
			        console.log("tips="+校验提示);
			    
			        if(校验提示){
			        }
			        
			       var 校验混合 = $(灵体).attr('validform');
				if(校验混合){
					varlidate_arr = 校验混合.split(',');
					for(var i in varlidate_arr){
						if(varlidate_arr[i] == 'required:true'){

							if($(灵体).val() == ''){
								//$(item).parent().append('<em for="'+em_for+'" generated="true" class="error tips">必填项</em>');
								alert(校验提示);
								通过检测 = false;
								return 通过检测;
							}else{
								//$(item).parent().append('<em for="'+em_for+'" generated="true" class="error success"></em>');
							}
							//break;
						}
					}
				}
				
			    });
				*/
			    
			 return 通过检测;
};
 


//全局
// 2. AJAX相关功能
// 全局AJAX设置
var cyberwin_ajaxSettings = {
    type: 'GET',
    url: '',
    data: null,
    async: true,
    headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
    },
    error: function() {},
    success: function() {},
    complete: function() {}
};

// AJAX设置方法
$cq.ajaxSetup = function(options) {
    for (var key in options) {
        if (options.hasOwnProperty(key)) {
			console.log("配置",key);
            cyberwin_ajaxSettings[key] = options[key];
        }
    }
};

// AJAX核心方法
$cq.ajax = function(options) {
    // 合并配置，优先级：调用时传入 > 全局设置
    var settings = {};
    for (var key in cyberwin_ajaxSettings) {
        settings[key] = cyberwin_ajaxSettings[key];
    }
    for (var key in options) {
        if (options.hasOwnProperty(key)) {
            settings[key] = options[key];
        }
    }

    // 创建XMLHttpRequest对象
    var xhr;
    if (window.XMLHttpRequest) {
        xhr = new XMLHttpRequest();
    } else {
        // 兼容IE6及以下
        xhr = new ActiveXObject("Microsoft.XMLHTTP");
    }

    // 处理数据
    var dataStr = '';
    if (settings.data && typeof settings.data === 'object') {
        for (var key in settings.data) {
            if (settings.data.hasOwnProperty(key)) {
                dataStr += encodeURIComponent(key) + '=' + encodeURIComponent(settings.data[key]) + '&';
            }
        }
        dataStr = dataStr.slice(0, -1);
    }

    // 处理URL（GET方法时附加数据）
    var url = settings.url;
    if (settings.type.toUpperCase() === 'GET' && dataStr) {
        url += (url.indexOf('?') > -1 ? '&' : '?') + dataStr;
        dataStr = null; // GET方法不需要send数据
    }

    // 打开连接
    xhr.open(settings.type, url, settings.async);

    // 设置请求头
    for (var key in settings.headers) {
        if (settings.headers.hasOwnProperty(key)) {
			console.log("配置设置请求头",key);
            xhr.setRequestHeader(key, settings.headers[key]);
        }
    }

    // 处理响应
	/*
    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4) {
            // 调用完成回调
            settings.complete(xhr);
            
            if (xhr.status >= 200 && xhr.status < 300) {
                // 成功回调
                var responseData;
                try {
                    // 尝试解析JSON
                    responseData = JSON.parse(xhr.responseText);
                } catch (e) {
                    // 解析失败则返回原始文本
                    responseData = xhr.responseText;
                }
                settings.success(responseData, xhr.status, xhr);
            } else {
                // 错误回调
                settings.error(xhr, xhr.status, xhr.statusText);
            }
        }
    };
*/
// 改进AJAX的错误处理部分
		xhr.onreadystatechange = function() {
			if (xhr.readyState === 4) {
				// 调用完成回调
				settings.complete(xhr);
				
				if (xhr.status >= 200 && xhr.status < 300) {
					// 成功回调（保持不变）
					var responseData;
					//dataType
					var wlzc_datatypereturn="normal";
					 if (options.hasOwnProperty("dataType")) {
                        wlzc_datatypereturn = options["dataType"];
					 }

					 if(wlzc_datatypereturn=="JSON"){
						 responseData = JSON.parse(xhr.responseText);
						 settings.success(responseData, xhr.status, xhr);
					 }
					 if(wlzc_datatypereturn=="normal"){
						 responseData = xhr.responseText;
					 }
/*
					try {
						responseData = JSON.parse(xhr.responseText);
					} catch (e) {
						responseData = xhr.responseText;
					}
					*/
					settings.success(responseData, xhr.status, xhr);
				} else {
					// 增强的错误信息
					var errorDetails = {
						status: xhr.status,
						statusText: xhr.statusText,
						response: xhr.responseText,
						type: xhr.status === 0 ? "网络错误" : "HTTP错误",
						message: xhr.status === 0 
							? "无法连接到服务器，可能是跨域问题或服务器未运行" 
							: "服务器返回错误状态: " + xhr.status + " " + xhr.statusText
					};
					
					// 调用错误回调并传递详细信息
					settings.error(xhr, errorDetails);

					 if (options.hasOwnProperty("error")) {
					     options.error(errorDetails);
				      }
				}
			}
		};
    // 发送请求
		 try{
			xhr.send(dataStr);
		 } catch (cyberwin_e) {
						//responseData = xhr.responseText;
						var errorDetails = {
                status: xhr.status,
                statusText: xhr.statusText,
                response: xhr.responseText,
                type: xhr.status === 0 ? "网络错误" : "HTTP错误",
                message: xhr.status === 0 
                    ? "无法连接到服务器，可能是跨域问题或服务器未运行" 
                    : "服务器返回错误状态: " + xhr.status + " " + xhr.statusText
						};
			  //console.log(errorDetails);
			   if (options.hasOwnProperty("error")) {
					options.error(errorDetails);
				}
			  //error
		 }
    
    // 返回xhr对象，方便中断请求等操作
    return xhr;
};

// 快捷GET方法
$cq.get = function(url, data, success, dataType) {
    // 处理参数重载
    if (typeof data === 'function') {
        dataType = success;
        success = data;
        data = null;
    }
    
    return $cq.ajax({
        type: 'GET',
        url: url,
        data: data,
        success: success
    });
};

// 快捷POST方法
$cq.post = function(url, data, success, dataType) {
    // 处理参数重载
    if (typeof data === 'function') {
        dataType = success;
        success = data;
        data = null;
    }
    
    return $cq.ajax({
        type: 'POST',
        url: url,
        data: data,
        success: success
    });
};

 cyberwin_query.prototype.serializeJson=function(){  
        var serializeObj={};  
        var array=this.serializeArray();  
        $(array).each(function(){  
            if(serializeObj[this.name]){  
                if($.isArray(serializeObj[this.name])){  
                    serializeObj[this.name].push(this.value);  
                }else{  
                    serializeObj[this.name]=[serializeObj[this.name],this.value];  
                }  
            }else{  
                serializeObj[this.name]=this.value;   
            }  
        });  
        return serializeObj;  
    }; 
 cyberwin_query.prototype.WLZC_serializeJson2024=function(){  
        var wlzc_serializeObj={};  
        var array=this.serializeArray();  
        $(array).each(function(){ 
			var wlzc_ei_name = this.name;
			//ymethod[1][paymethod_id]
			var ie = wlzc_ei_name.indexOf("[");
			if(ie >=0){
				//console.log("未来之窗编码，存在" + wlzc_ei_name);
				var wlzc_ei_name_yh1 =wlzc_ei_name.replace(/]/g,"");
				const wlzc_ei_name_Array = wlzc_ei_name_yh1.split("[");
				//console.log("未来之窗编码，分组");
				const  wlzc_ei_len = wlzc_ei_name_Array.length;
				console.log(wlzc_ei_name_Array);
				if(wlzc_ei_len == 3){
					var array_1 =wlzc_ei_name_Array[0];
					var array_2 =wlzc_ei_name_Array[1];
					var array_3 =wlzc_ei_name_Array[2];
					//错误 wlzc_serializeObj[array_1][array_2][array_3]=this.value;  
					//var jsonobj = array_2[array_3]=this.value;  
					var jsonobj_3=Array();
                    jsonobj_3[array_3]=this.value;  
					//console.log("未来之窗编码，分组jsonobj_3");
					//console.log(jsonobj_3);

					var jsonobj_2=Array();
                    jsonobj_2[array_2] = jsonobj_3;  
					//console.log("未来之窗编码，分组jsonobj_2");
					//console.log(jsonobj_2);
					//wlzc_serializeObj[array_1]=jsonobj_2;
					if(wlzc_serializeObj[array_1]){ 
                       
					}else{
					//	wlzc_serializeObj[array_1]=[];  
						wlzc_serializeObj[array_1]={};  
					}

					if(wlzc_serializeObj[array_1][array_2]){ 
                       
					}else{
						// wlzc_serializeObj[array_1][array_2]=[]; 
						  wlzc_serializeObj[array_1][array_2]={}; 
					}

					if(wlzc_serializeObj[array_1][array_2][array_3]){ 
                       wlzc_serializeObj[array_1][array_2][array_3]=this.value;  
					}else{
						 wlzc_serializeObj[array_1][array_2][array_3]=this.value;  
						 
					}

				}
			}else{
               //未来之窗
				if(wlzc_serializeObj[this.name]){  
					if($.isArray(wlzc_serializeObj[this.name])){  
						wlzc_serializeObj[this.name].push(this.value);  
					}else{  
						wlzc_serializeObj[this.name]=[wlzc_serializeObj[this.name],this.value];  
					}  
				}else{  
					wlzc_serializeObj[this.name]=this.value;   
				}

			}
        });  
        return wlzc_serializeObj;  
    }; 

// 3. 添加WLZC_serializeJson方法
cyberwin_query.prototype.WLZC_serializeJson = function() {
    var wlzc_serializeObj = {};
    var elements = this.elements[0] ? this.elements[0].elements : [];
    
    // 收集表单数据
    var array = [];
    for (var i = 0; i < elements.length; i++) {
        var elem = elements[i];
        // 跳过禁用的元素和没有name属性的元素
        if (elem.disabled || !elem.name) continue;
        
        // 处理复选框和单选按钮
        if ((elem.type === 'checkbox' || elem.type === 'radio') && !elem.checked) continue;
        
        array.push({
            name: elem.name,
            value: elem.value
        });
    }
    
    // 处理数据结构
    for (var i = 0; i < array.length; i++) {
        var item = array[i];
        var wlzc_ei_name = item.name;
        var ie = wlzc_ei_name.indexOf("[");
        
        if (ie >= 0) {
            // 处理数组形式的name，如ymethod[1][paymethod_id]
            var wlzc_ei_name_yh1 = wlzc_ei_name.replace(/]/g, "");
            var wlzc_ei_name_Array = wlzc_ei_name_yh1.split("[");
            var wlzc_ei_len = wlzc_ei_name_Array.length;
            
            if (wlzc_ei_len === 3) {
                var array_1 = wlzc_ei_name_Array[0];
                var array_2 = wlzc_ei_name_Array[1];
                var array_3 = wlzc_ei_name_Array[2];
                
                // 初始化嵌套对象
                if (!wlzc_serializeObj[array_1]) {
                    wlzc_serializeObj[array_1] = {};
                }
                if (!wlzc_serializeObj[array_1][array_2]) {
                    wlzc_serializeObj[array_1][array_2] = {};
                }
                
                // 赋值
                wlzc_serializeObj[array_1][array_2][array_3] = item.value;
            }
        } else {
            // //未来之窗
            if (wlzc_serializeObj[wlzc_ei_name]) {
                if (Array.isArray(wlzc_serializeObj[wlzc_ei_name])) {
                    wlzc_serializeObj[wlzc_ei_name].push(item.value);
                } else {
                    wlzc_serializeObj[wlzc_ei_name] = [wlzc_serializeObj[wlzc_ei_name], item.value];
                }
            } else {
                wlzc_serializeObj[wlzc_ei_name] = item.value;
            }
        }
    }
    
    return wlzc_serializeObj;
};

cyberwin_query.prototype.showAlert = function(message, type ="info", duration = 1000,titleText) {
    const existingAlert = document.querySelector('.fairy_cyberwinqueryvalert_overlay');
    if (existingAlert) {
                existingAlert.remove();
    }
    const AlertType = {
            INFO: 'info',
            SUCCESS: 'success',
            WARNING: 'warning',
            ERROR: 'error'
        };
		// 创建            // 创建遮罩层
            const overlay = document.createElement('div');
             
			overlay.className = 'fairy_cyberwinqueryvalert_overlay';
			overlay.id = 'fairy_cyberwinqueryvalert_overlay_hhaha';
            
            // 创建提示框容器
            const alertBox = document.createElement('div');
           
		  
            
            // 设置提示框头部样式（根据类型）
            let headerClass, iconClass;
            switch(type) {
                case AlertType.SUCCESS:
                    headerClass = 'bg-success text-white';
                    iconClass = 'fa-check-circle';
                    break;
                case AlertType.WARNING:
                    headerClass = 'bg-warning text-white';
                    iconClass = 'fa-exclamation-triangle';
                    break;
                case AlertType.ERROR:
                    headerClass = 'bg-danger text-white';
                    iconClass = 'fa-times-circle';
                    break;
                default:
                    headerClass = 'bg-primary text-white';
                    iconClass = 'fa-info-circle';
            }

			 alertBox.className = `fairy_cyberwinqueryvalert_alert_box fairy_cyberwinqueryvalertty-${type} alert-enter`;
            // alertBox.className = `alert-box alert-${type} alert-enter`;
            // 设置提示框内容
			 // 设置标题文本
            //const titleText = type === AlertType.INFO ? '提示' : 
            //                 type === AlertType.SUCCESS ? '成功' : 
           //                  type === AlertType.WARNING ? '警告' : '错误';
            // 设置提示框内容
		    const 未来之窗style = `
			<style>
			/* 遮罩层样式 */
        .fairy_cyberwinqueryvalert_overlay {
            position: fixed;
            top: 0;
            left: 0;
            right: 0;
            bottom: 0;
            background-color: rgba(0, 0, 0, 0.5);
            display: flex;
            justify-content: center;
            align-items: center;
            z-index: 1000;
        }
		 .fairy_cyberwinqueryvalert_alert_box {
            background-color: white;
            border-radius: 8px;
            width: 90%;
            max-width: 400px;
            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
            overflow: hidden;
        }

		 .fairy_cyberwinqueryvalert_alert_header {
            padding: 16px 20px;
            display: flex;
            justify-content: space-between;
            align-items: center;
            color: white;
            font-weight: 600;
            font-size: 18px;
			 
        }
		 

        .fairy_cyberwinqueryvalertty-info .fairy_cyberwinqueryvalert_alert_header {
            background-color: #165DFF;
        }

        .fairy_cyberwinqueryvalertty-success .fairy_cyberwinqueryvalert_alert_header {
            background-color: #00B42A;
        }

        .fairy_cyberwinqueryvalertty-warning .fairy_cyberwinqueryvalert_alert_header {
            background-color: #FF7D00;
        }

        .fairy_cyberwinqueryvalertty-error .fairy_cyberwinqueryvalert_alert_header {
            background-color: #F53F3F;
        }

        /* 提示内容 */
        .fairy_cyberwinqueryvalert_alert_content {
            padding: 20px;
            font-size: 16px;
            color: #333;
            line-height: 1.5;
        }

        /* 按钮区域 */
        .fairy_cyberwinqueryvalert_alert_footer {
            padding: 12px 20px;
            background-color: #f5f5f5;
            display: flex;
            justify-content: flex-end;
        }

        .fairy_cyberwinqueryvalert_alert_footer button {
            background-color: #165DFF;
            color: white;
            padding: 8px 16px;
            font-size: 14px;
        }

        .fairy_cyberwinqueryvalert_alert_footer button:hover {
            background-color: #0E42D2;
        }

        /* 关闭按钮 */
        .fairy_cyberwinqueryvalert_alert_close_btn {
            background: none;
            border: none;
            color: inherit;
            font-size: 20px;
            cursor: pointer;
            padding: 0;
            width: 24px;
            height: 24px;
            display: flex;
            align-items: center;
            justify-content: center;
        }

		</style>
		`;
            const 未来之窗mess = `
                <div class="fairy_cyberwinqueryvalert_alert_header fairy_cyberwinqueryvalertty-${type}">
                    <span>${titleText}</span>
                    <button class="fairy_cyberwinqueryvalert_alert_close_btn" onClick=" setTimeout(() => {
                    document.getElementById('fairy_cyberwinqueryvalert_overlay_hhaha').remove();
                }, 300);">&times;</button>
                </div>
                <div class="fairy_cyberwinqueryvalert_alert_content">
                    <p>${message}</p>
                </div>
                <div class="fairy_cyberwinqueryvalert_alert_footer">
                    <button class="confirm-btn" onClick=" setTimeout(() => {
                    document.getElementById('fairy_cyberwinqueryvalert_overlay_hhaha').remove();
                }, 300);">确定</button>
                </div>
            `;


			 alertBox.innerHTML = 未来之窗style+未来之窗mess;
            
            
            // 将提示框添加到遮罩层
            overlay.appendChild(alertBox);
            // 将遮罩层添加到页面
            document.body.appendChild(overlay);
            
            // 获取关闭按钮并添加事件
           // const closeBtn = alertBox.querySelector('.close-btn');
           // const confirmBtn = alertBox.querySelector('.confirm-btn');
            
          
            
            // 添加关闭事件
            //closeBtn.addEventListener('click', closeAlert);
           // confirmBtn.addEventListener('click', closeAlert);
            
            // 点击遮罩层关闭（可选）
			/*
            overlay.addEventListener('click', (e) => {
                if (e.target === overlay) {
                    closeAlert();
                }
            });
            */
            // 自动关闭（如果设置了duration）
            if (duration > 0) {
                setTimeout(closeAlert, duration);
            }
}

  